Locators are one of the most important concepts in Selenium WebDriver. A locator is a mechanism used by Selenium to identify and locate a specific web element on a web page so that the automation script can interact with it.
Web applications contain many elements such as text boxes, buttons, links, checkboxes, radio buttons, dropdowns, images, forms, tables, and menus. Selenium needs a reliable way to identify these elements before performing actions such as click(), sendKeys(), clear(), getText(), or getAttribute().
For example, if an application contains a Login button, Selenium first needs to locate that button and then perform the click operation.
driver.findElement(By.id("login")).click();Here, By.id("login") is the locator strategy and Selenium uses it to identify the Login element.
Locators are a core part of Selenium WebDriver automation and are used along with Web Elements, browser automation, forms, buttons, dropdowns, navigation, waits, dynamic elements, and framework development.
For structured Selenium automation learning, you can explore the JustAcademy's Selenium Training Course and use the Register for Course Demo option.
A locator is an address or identification strategy used by Selenium WebDriver to find a particular element in the HTML DOM of a web page.
In simple words:
Locator = Way to identify a web elementFor example:
WebElement username = driver.findElement(
By.id("username")
);
In this example:
WebElement represents the web element.driver.findElement() searches for the element.By.id() specifies the locator strategy."username" is the locator value.Selenium cannot interact with a web element unless it can identify that element. Therefore, locators are essential for almost every Selenium automation script.
Locators are used to:
The most common syntax for locating an element is:
driver.findElement(By.locatorStrategy("locatorValue"));Example:
driver.findElement(By.id("username"));Another example:
driver.findElement(
By.xpath("//input[@name='email']")
);
Selenium WebDriver provides several locator strategies for identifying elements.
| Locator | Method | Example |
|---|---|---|
| ID | By.id() | By.id("username") |
| Name | By.name() | By.name("email") |
| Class Name | By.className() | By.className("login-btn") |
| Tag Name | By.tagName() | By.tagName("input") |
| Link Text | By.linkText() | By.linkText("Login") |
| Partial Link Text | By.partialLinkText() | By.partialLinkText("Log") |
| CSS Selector | By.cssSelector() | By.cssSelector("#username") |
| XPath | By.xpath() | By.xpath("//input[@id='username']") |
The ID locator identifies an element using its HTML id attribute.
Example HTML:
<input type="text" id="username">Selenium code:
WebElement username = driver.findElement(
By.id("username")
);
To enter text:
driver.findElement(
By.id("username")
).sendKeys("admin");
The name locator identifies an element using the HTML name attribute.
Example:
<input type="text" name="username">Selenium:
driver.findElement(
By.name("username")
).sendKeys("admin");
Name locator is useful when:
The class name locator identifies an element using the HTML class attribute.
<button class="login-button">
Login
</button>
Selenium:
driver.findElement(
By.className("login-button")
).click();
When an element contains multiple classes, By.className() should be given a single class name rather than the complete space-separated class attribute.
For example:
<button class="btn btn-primary login-btn">
Login
</button>
Correct:
By.className("login-btn")Incorrect:
By.className("btn btn-primary login-btn")Tag name identifies an element using its HTML tag.
driver.findElement(
By.tagName("input")
);
Common tag names include:
inputbuttonaselecttextareaimgtabledivfindElements() can be used when multiple elements need to be retrieved.
List<WebElement> links =
driver.findElements(By.tagName("a"));
System.out.println(
"Total links: " + links.size()
);
linkText() is specifically used for locating links using their complete visible text.
HTML:
<a href="/login">Login</a>Selenium:
driver.findElement(
By.linkText("Login")
).click();
partialLinkText() locates a link using a portion of its visible text.
HTML:
<a href="/registration">
Create New Account
</a>
Selenium:
driver.findElement(
By.partialLinkText("Create")
).click();
| Feature | linkText | partialLinkText |
|---|---|---|
| Matching | Complete text | Partial text |
| Precision | Usually higher | Can be less precise |
| Usage | Stable complete text | Known portion of text |
| Risk | Breaks if text changes | May match multiple links |
CSS Selector is a powerful locator strategy that uses CSS syntax to identify elements.
driver.findElement(
By.cssSelector("#username")
);
CSS selectors can identify elements using:
CSS uses # to represent an ID.
By.cssSelector("#username")Equivalent XPath:
By.xpath("//input[@id='username']")CSS uses . to represent a class.
By.cssSelector(".login-button")HTML:
<button class="login-button">
Login
</button>
By.cssSelector("button.login-button")This means find a button element having the class login-button.
By.cssSelector(
"input[name='username']"
)
HTML:
<input name="username">By.cssSelector(
"input[type='text'][name='username']"
)
Multiple attributes can make a locator more specific.
The *= operator checks whether an attribute contains a specified value.
By.cssSelector(
"input[id*='user']"
)
The ^= operator checks whether an attribute starts with a specified value.
By.cssSelector(
"input[id^='user']"
)
The $= operator checks whether an attribute ends with a specified value.
By.cssSelector(
"input[id$='name']"
)
By.cssSelector(
"form.login-form input"
)
This finds an input element inside an element having the login-form class.
XPath is a query language used to navigate and locate elements in an HTML or XML document. Selenium supports XPath as one of its most powerful locator strategies.
driver.findElement(
By.xpath("//input[@id='username']")
);
Absolute XPath starts from the root of the HTML document.
/html/body/div/form/inputAbsolute XPath is generally fragile because any structural change in the page can break the locator.
Relative XPath generally starts with // and identifies elements based on attributes or relationships.
//input[@id='username']Relative XPath is usually preferred over long absolute XPath expressions.
By.xpath("//input[@id='username']")By.xpath("//input[@name='username']")By.xpath(
"//button[@class='login-button']"
)
By.xpath(
"//input[@type='text' and @name='username']"
)
The text() function can identify an element based on its visible text.
By.xpath(
"//button[text()='Login']"
)
contains() is useful when an attribute or text contains a stable portion of the value.
By.xpath(
"//input[contains(@id,'user')]"
)
Example:
<input id="user_12345">By.xpath(
"//button[contains(text(),'Login')]"
)
starts-with() is useful when the beginning of an attribute value is stable.
By.xpath(
"//input[starts-with(@id,'user_')]"
)
The and operator allows multiple conditions.
By.xpath(
"//input[@type='text' and @name='username']"
)
The or operator allows alternative conditions.
By.xpath(
"//input[@id='username' or @name='username']"
)
By.xpath(
"//label[text()='Username']/parent::div"
)
By.xpath(
"//div[@class='login-form']/child::input"
)
By.xpath(
"//form[@id='loginForm']//input"
)
By.xpath(
"//label[text()='Username']/following-sibling::input"
)
By.xpath(
"//label[text()='Username']/following::input[1]"
)
By.xpath(
"//input[@id='password']/preceding::label[1]"
)
An index can be used when multiple elements match the same XPath.
By.xpath("(//input[@type='text'])[2]")Index-based locators should be used carefully because page structure changes can change element positions.
normalize-space() can help when visible text contains unwanted leading, trailing, or repeated whitespace.
By.xpath(
"//button[normalize-space()='Login']"
)
By.xpath(
"//input[starts-with(@id,'user') and contains(@class,'field')]"
)
Modern applications often generate dynamic IDs such as:
user_483920
user_728391
user_918273
Instead of using the complete dynamic value, use a stable portion:
By.xpath(
"//input[starts-with(@id,'user_')]"
)
| Situation | Recommended Locator |
|---|---|
| Unique stable ID | ID |
| Stable name attribute | Name |
| Stable class | Class Name or CSS |
| Link with stable text | Link Text |
| Partially known link text | Partial Link Text |
| Simple attribute selection | CSS Selector |
| Complex relationship | XPath |
| Dynamic attributes | CSS or XPath with stable portions |
There is no universal ranking that guarantees one locator is always the best. The practical goal is to choose a locator that is unique, stable, readable, and resistant to expected UI changes.
A practical preference is:
A good locator should identify the intended element without accidentally matching unrelated elements.
By.id("username")If the ID is unique and stable, this is usually straightforward.
Sometimes the same locator identifies multiple elements.
List<WebElement> buttons =
driver.findElements(
By.className("btn")
);
System.out.println(
buttons.size()
);
When multiple elements match, a more specific locator may be required.
| Method | Return Type | Purpose |
|---|---|---|
findElement() | WebElement | Find one matching element |
findElements() | List<WebElement> | Find all matching elements |
WebElement username =
driver.findElement(
By.id("username")
);
List<WebElement> links =
driver.findElements(
By.tagName("a")
);
If Selenium cannot find an element using findElement(), it generally throws NoSuchElementException.
WebElement element =
driver.findElement(
By.id("incorrectId")
);
If the element does not exist, Selenium reports a NoSuchElementException.
findElements() generally returns an empty list when no matching elements are found.
List<WebElement> elements =
driver.findElements(
By.className("missing")
);
System.out.println(
elements.size()
);
A locator identifies an element, while WebElement represents the element returned by Selenium.
By usernameLocator =
By.id("username");
WebElement username =
driver.findElement(
usernameLocator
);
username.sendKeys("admin");
After locating an element, Selenium can perform various operations.
| Action | Method |
|---|---|
| Click | click() |
| Enter text | sendKeys() |
| Clear text | clear() |
| Get visible text | getText() |
| Get attribute | getAttribute() |
| Check visibility | isDisplayed() |
| Check enabled state | isEnabled() |
| Check selection | isSelected() |
WebElement username =
driver.findElement(
By.id("username")
);
username.sendKeys("admin");
driver.findElement(
By.name("password")
).sendKeys("secret123");
driver.findElement(
By.id("loginButton")
).click();
driver.findElement(
By.id("rememberMe")
).click();
driver.findElement(
By.cssSelector(
"input[value='male']"
)
).click();
WebElement country =
driver.findElement(
By.id("country")
);
driver.findElement(
By.linkText("About Us")
).click();
WebElement image =
driver.findElement(
By.cssSelector("img.logo")
);
WebElement table =
driver.findElement(
By.id("employeeTable")
);
WebElement form =
driver.findElement(
By.id("registrationForm")
);
Modern applications frequently provide stable custom attributes such as data-testid, data-id, or data-qa specifically for testing and automation.
<button data-testid="login-button">
Login
</button>
CSS:
By.cssSelector(
"[data-testid='login-button']"
)
XPath:
By.xpath(
"//button[@data-testid='login-button']"
)
Some applications generate classes dynamically.
button-Mx82Qa
button-Ap91Lm
button-Xz72Rt
Instead of depending on the complete class, look for a stable attribute or stable class portion.
By.cssSelector(
"button[class*='button-']"
)
For dynamic IDs:
user_83921
user_47291
user_58372
Use:
By.xpath(
"//input[starts-with(@id,'user_')]"
)
If the visible text changes but contains a stable word, contains() can be useful.
By.xpath(
"//button[contains(text(),'Submit')]"
)
By.xpath(
"//div[contains(@class,'product')]//a[contains(text(),'Laptop')]"
)
When multiple elements have similar attributes, first identify a unique parent and then search inside it.
WebElement loginForm =
driver.findElement(
By.id("loginForm")
);
WebElement username =
loginForm.findElement(
By.name("username")
);
WebElement row =
driver.findElement(
By.xpath(
"//tr[td[text()='John']]"
)
);
WebElement edit =
row.findElement(
By.linkText("Edit")
);
edit.click();
WebElement modal =
driver.findElement(
By.id("loginModal")
);
modal.findElement(
By.id("username")
).sendKeys("admin");
Selenium must switch to the appropriate iframe before locating an element inside it.
driver.switchTo().frame("loginFrame");
driver.findElement(
By.id("username")
).sendKeys("admin");
driver.switchTo().defaultContent();
driver.switchTo().frame("outerFrame");
driver.switchTo().frame("innerFrame");
driver.findElement(
By.id("username")
).sendKeys("admin");
driver.switchTo().defaultContent();
Modern web applications may use Shadow DOM to encapsulate elements.
WebElement host =
driver.findElement(
By.cssSelector("custom-login")
);
SearchContext shadowRoot =
host.getShadowRoot();
WebElement username =
shadowRoot.findElement(
By.cssSelector("#username")
);
Explicit waits commonly receive a locator and wait until a specific condition is satisfied.
WebDriverWait wait =
new WebDriverWait(
driver,
Duration.ofSeconds(10)
);
WebElement login =
wait.until(
ExpectedConditions.elementToBeClickable(
By.id("login")
)
);
login.click();
WebElement username =
wait.until(
ExpectedConditions.visibilityOfElementLocated(
By.id("username")
)
);
WebElement element =
wait.until(
ExpectedConditions.presenceOfElementLocated(
By.id("username")
)
);
In Page Object Model, locators are generally stored as page-level fields so that page interaction logic remains organized and maintainable.
public class LoginPage {
WebDriver driver;
By username =
By.id("username");
By password =
By.id("password");
By loginButton =
By.id("login");
public LoginPage(WebDriver driver) {
this.driver = driver;
}
public void enterUsername(String value) {
driver.findElement(username)
.sendKeys(value);
}
public void enterPassword(String value) {
driver.findElement(password)
.sendKeys(value);
}
public void clickLogin() {
driver.findElement(loginButton)
.click();
}
}
A locator can be declared once and reused multiple times.
By usernameLocator =
By.id("username");
driver.findElement(
usernameLocator
).sendKeys("admin");
driver.findElement(
usernameLocator
).clear();
driver.findElement(
usernameLocator
).sendKeys("testuser");
public WebElement find(
WebDriver driver,
By locator) {
return driver.findElement(locator);
}
Usage:
WebElement username =
find(
driver,
By.id("username")
);
public WebElement waitForElement(
WebDriver driver,
By locator) {
WebDriverWait wait =
new WebDriverWait(
driver,
Duration.ofSeconds(10)
);
return wait.until(
ExpectedConditions.visibilityOfElementLocated(
locator
)
);
}
/html/body/div[2]/div[1]/form/div[2]/input[1]This type of XPath is fragile because changes in the DOM hierarchy can break the locator.
//input[@id='username']A relative XPath based on a stable attribute is generally easier to maintain.
(//button)[8]This may work temporarily but can fail when another button is added before the eighth button.
//button[@id='submitButton']A locator should ideally identify the intended element uniquely.
List<WebElement> elements =
driver.findElements(
By.cssSelector("#username")
);
System.out.println(
"Matching elements: " +
elements.size()
);
If a locator expected to identify one element returns many matches, it should be made more specific.
Locator stability refers to how well a locator continues to work when the application changes.
| Locator Type | Potential Stability |
|---|---|
| Stable ID | High |
| Stable data-testid | High |
| Stable name | High |
| Stable CSS | High |
| Visible text | Depends on content changes |
| Dynamic class | Low |
| Absolute XPath | Low |
| Position-only XPath | Low |
A good locator should be understandable to another tester or developer.
Less readable:
//div[3]/div[2]/button[1]More readable:
//button[@id='loginButton']Maintainable locators are based on attributes or relationships that are unlikely to change unnecessarily.
Modern applications frequently use React, Angular, Vue, AJAX, dynamic components, asynchronous rendering, and generated attributes. Because of this, locator design is especially important.
For dynamic applications:
<button data-testid="login-button">
Login
</button>
Selenium:
driver.findElement(
By.cssSelector(
"[data-testid='login-button']"
)
).click();
Angular applications can expose attributes and classes that may be useful for locating elements, but testers should prefer stable application attributes over framework-specific implementation details.
driver.findElement(
By.cssSelector(
"input[name='username']"
)
).sendKeys("admin");
Accessibility attributes such as aria-label can sometimes provide useful and meaningful locator values.
<button aria-label="Search">
<span>🔍</span>
</button>
CSS:
driver.findElement(
By.cssSelector(
"button[aria-label='Search']"
)
).click();
<input
type="text"
placeholder="Enter username">
driver.findElement(
By.cssSelector(
"input[placeholder='Enter username']"
)
).sendKeys("admin");
<input
type="radio"
value="male">
driver.findElement(
By.cssSelector(
"input[value='male']"
)
).click();
driver.findElement(
By.cssSelector(
"input[type='password']"
)
);
driver.findElement(
By.cssSelector(
"input[type='text'][name='username']"
)
);
| Element | Example Locator |
|---|---|
| Username | By.id("username") |
| Password | By.id("password") |
| Login button | By.id("loginButton") |
| Forgot password | By.linkText("Forgot Password") |
| Remember checkbox | By.id("rememberMe") |
driver.findElement(
By.id("username")
).sendKeys("admin");
driver.findElement(
By.id("password")
).sendKeys("admin123");
driver.findElement(
By.id("loginButton")
).click();
| Element | Locator Example |
|---|---|
| First Name | By.name("firstName") |
| Last Name | By.name("lastName") |
By.id("email") | |
| Password | By.id("password") |
| Country | By.id("country") |
| Register button | By.cssSelector("button[type='submit']") |
| Element | Locator Example |
|---|---|
| Search box | By.id("search") |
| Search button | By.cssSelector("button.search") |
| Product link | By.xpath("//a[contains(text(),'Laptop')]") |
| Add to cart | By.id("addToCart") |
| Cart link | By.linkText("Cart") |
WebElement row =
driver.findElement(
By.xpath(
"//tr[td[text()='John']]"
)
);
WebElement edit =
row.findElement(
By.linkText("Edit")
);
edit.click();
driver.findElement(
By.xpath(
"//table[@id='users']//tr" +
"[td[contains(text(),'John')]]" +
"//button[contains(text(),'Edit')]"
)
).click();
driver.findElement(
By.xpath(
"//select[@id='country']" +
"//option[text()='India']"
)
).click();
driver.findElement(
By.cssSelector(
"input[name='gender'][value='male']"
)
).click();
driver.findElement(
By.cssSelector(
"input[name='terms']"
)
).click();
driver.findElement(
By.xpath(
"//div[contains(@class,'search-result')]" +
"//a[contains(text(),'Selenium')]"
)
).click();
driver.findElement(
By.xpath(
"//nav//a[text()='Products']"
)
).click();
driver.findElement(
By.xpath(
"//footer//a[text()='Privacy Policy']"
)
).click();
WebElement modal =
driver.findElement(
By.cssSelector(".modal")
);
modal.findElement(
By.cssSelector(
"button[type='submit']"
)
).click();
By loginButton =
By.id("loginButton");
WebDriverWait wait =
new WebDriverWait(
driver,
Duration.ofSeconds(10)
);
WebElement button =
wait.until(
ExpectedConditions.elementToBeClickable(
loginButton
)
);
button.click();
@Test
public void verifyLoginButton() {
WebElement button =
driver.findElement(
By.id("loginButton")
);
Assert.assertTrue(
button.isDisplayed()
);
Assert.assertTrue(
button.isEnabled()
);
}
public class LoginPage {
private WebDriver driver;
private By username =
By.id("username");
private By password =
By.id("password");
private By login =
By.id("loginButton");
public LoginPage(WebDriver driver) {
this.driver = driver;
}
public void login(
String user,
String pass) {
driver.findElement(username)
.sendKeys(user);
driver.findElement(password)
.sendKeys(pass);
driver.findElement(login)
.click();
}
}
When a locator fails, follow a systematic debugging process.
data-testid when provided.A locator is a strategy used by Selenium WebDriver to identify a specific web element in the DOM so that the automation script can interact with it.
Selenium provides eight commonly used locator strategies: ID, Name, Class Name, Tag Name, Link Text, Partial Link Text, CSS Selector, and XPath.
linkText() and partialLinkText() are specifically designed for links. CSS and XPath can also locate links.
findElement() returns one matching WebElement and throws an exception when no matching element is found. findElements() returns a list and generally returns an empty list when there are no matches.
Absolute XPath starts from the root of the document and usually depends heavily on DOM structure. Relative XPath generally starts with // and identifies elements through attributes, text, or relationships.
contains() is used when only part of an attribute value or text is stable.
starts-with() identifies elements where an attribute or string begins with a specified value.
Neither is universally better. The appropriate choice depends on the application's DOM, locator stability, readability, and the relationship needed to identify the element.
Absolute XPath is highly dependent on the exact DOM hierarchy. Small structural changes can cause it to fail.
Use a stable attribute or a dynamic XPath/CSS expression that targets the stable portion of the value, such as starts-with(), contains(), or CSS attribute matching.
Create a complete Selenium login automation test using appropriate locators.
Test flow:
driver.get("https://example.com/login");
driver.findElement(
By.id("username")
).sendKeys("admin");
driver.findElement(
By.id("password")
).sendKeys("admin123");
driver.findElement(
By.id("loginButton")
).click();
WebDriverWait wait =
new WebDriverWait(
driver,
Duration.ofSeconds(10)
);
wait.until(
ExpectedConditions.urlContains(
"/dashboard"
)
);
Assert.assertTrue(
driver.getCurrentUrl()
.contains("/dashboard")
);
Create a registration automation project using multiple locator strategies.
driver.findElement(
By.name("firstName")
).sendKeys("John");
driver.findElement(
By.name("lastName")
).sendKeys("Doe");
driver.findElement(
By.id("email")
).sendKeys("[email protected]");
driver.findElement(
By.cssSelector(
"input[name='terms']"
)
).click();
driver.findElement(
By.xpath(
"//button[text()='Register']"
)
).click();
Automate an e-commerce website using different locator strategies.
driver.findElement(
By.id("search")
).sendKeys("Laptop");
driver.findElement(
By.cssSelector("button.search")
).click();
driver.findElement(
By.xpath(
"//a[contains(text(),'Laptop')]"
)
).click();
driver.findElement(
By.id("addToCart")
).click();
driver.findElement(
By.linkText("Cart")
).click();
| Locator | Syntax | Best Use |
|---|---|---|
| ID | By.id() | Unique stable ID |
| Name | By.name() | Stable name attribute |
| Class Name | By.className() | Unique stable class |
| Tag Name | By.tagName() | Finding elements by tag |
| Link Text | By.linkText() | Exact link text |
| Partial Link Text | By.partialLinkText() | Partial link text |
| CSS Selector | By.cssSelector() | Flexible CSS-based identification |
| XPath | By.xpath() | Complex relationships and dynamic elements |
Locators are the foundation of Selenium WebDriver automation. Selenium uses locators to identify web elements before performing actions such as clicking, entering text, selecting options, checking states, reading text, and validating application behavior.
The major Selenium locator strategies are ID, Name, Class Name, Tag Name, Link Text, Partial Link Text, CSS Selector, and XPath. Selecting the appropriate locator depends on the HTML structure, stability of attributes, uniqueness, readability, and maintainability of the automation script.
For modern dynamic applications, testers should understand CSS selectors, XPath functions such as contains() and starts-with(), custom test attributes, explicit waits, iframe handling, Shadow DOM, and Page Object Model. A well-designed locator strategy makes Selenium automation more stable, readable, reusable, and easier to maintain.
For comprehensive Selenium automation training covering WebDriver, locators, Web Elements, forms, dropdowns, waits, TestNG, Page Object Model, frameworks, cross-browser testing, reporting, CI/CD, and real-time projects, visit the JustAcademy's Selenium Training Course.
To register for a course demo, visit the Register for Course Demo page.
